home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / ShellTView.C < prev    next >
C/C++ Source or Header  |  1992-08-05  |  16KB  |  721 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "ShellTView.h"
  6.  
  7. #include "Class.h"
  8. #include "Iterator.h"
  9. #include "OrdColl.h"
  10. #include "ByteArray.h"
  11. #include "StyledText.h"
  12. #include "System.h"
  13. #include "String.h"
  14. #include "Alert_e.h"
  15. #include "Menu.h"
  16. #include "MenuBar.h"
  17. #include "Window.h"
  18. #include "WindowSystem.h"
  19. #include "Math.h"
  20.  
  21. char *gDefaultArgv[] = { "/bin/csh", 0 };
  22.  
  23. const int cPttyBufSize      = 8192,
  24.       cHighWaterMark    = 50000,
  25.       cLowWaterMark     = 4000,
  26.       cESC              = 27;
  27.  
  28. //---- output cursor (reversed caret) --------------------------------------
  29.  
  30. const int crevCaretHeight = 4,
  31.       crevCaretWidth  = 7;
  32.  
  33. static u_short revCaretBits[]= {
  34. #   include "images/revCaret.image"
  35. };
  36.  
  37. static SmartBitmap gRevCaretImage(Point(crevCaretWidth,crevCaretHeight),
  38.                                 revCaretBits);
  39.  
  40. static RGBColor *gCaretColor;
  41.  
  42. //---- class PttyInputHandler --------------------------------------------------
  43.  
  44. class PttyInputHandler : public SysEvtHandler {
  45.     FILE *fp;
  46.     ShellTextView *tv;
  47. public:
  48.     MetaDef(PttyInputHandler);
  49.     PttyInputHandler(FILE *f, ShellTextView *t) : SysEvtHandler(fileno(f))
  50.     { fp= f; tv= t; }
  51.     void Notify(SysEventCodes, int)
  52.     { tv->Received(); }
  53. };
  54.  
  55. NewMetaImpl(PttyInputHandler, SysEvtHandler, (TP(tv)));
  56.  
  57. //---- ShellZombieHandler ------------------------------------------------------
  58.  
  59. class ShellZombieHandler : public SysEvtHandler {
  60.     ShellTextView *sh;
  61. public:
  62.     MetaDef(ShellZombieHandler);
  63.     ShellZombieHandler(int pid, ShellTextView *t) : SysEvtHandler(pid)
  64.     { sh= t;}
  65.     void Notify(SysEventCodes, int)
  66.     { sh->SlaveDied(); }
  67. };
  68.  
  69. NewMetaImpl(ShellZombieHandler, SysEvtHandler, (TP(sh)));
  70.  
  71. //---- class ShellTextView -----------------------------------------------------
  72.     
  73. NewMetaImpl(ShellTextView, TextView, (TP(outputCursor), TP(inputCursor), 
  74.                TP(zombieHandler), TP(pttyinp), TB(pendingCR),
  75.                TB(doReveal), TP(noEchoBuffer), T(lastSubmit),
  76.                T(maxLogSize), T(state), TP(pttycstr), 
  77.                TSP(argv), 0));
  78.                
  79. ShellTextView::ShellTextView(
  80.     EvtHandler *eh, Rectangle r, Text *t,
  81.     char *name, char **args, bool cons, 
  82.     TextViewFlags fl, Point b
  83. ) : TextView(eh, r, t, TRUE, fl, b, eTViewLeft) 
  84. {
  85.     Init(TRUE, name, args, cons);
  86. }   
  87.  
  88. void ShellTextView::Init(bool reveal, char *name, char **args, bool cons)
  89. {
  90.     doReveal= reveal;
  91.     outputCursor= new Mark(0, 0, eStateNone, (eMarkFlags)eMarkNone);
  92.     inputCursor= new Mark(0, 0, eStateNone, (eMarkFlags)eMarkNone);
  93.  
  94.     linebuf= 0;
  95.     pendingCR= FALSE;
  96.     inReceive= FALSE;
  97.     maxLogSize= cHighWaterMark;
  98.     noEchoBuffer= new GapText(20);
  99.     inpQueue= new OrdCollection;
  100.     GetText()->AddMark(outputCursor);
  101.     GetText()->AddMark(inputCursor);
  102.     gSystem->Setenv("TERM", GetTerm());
  103.     gSystem->Setenv("TERMCAP", GetTermCap());
  104.     pttycon= 0;
  105.     Start(name, args, cons);
  106. }
  107.  
  108. ShellTextView::~ShellTextView()
  109. {
  110.     Term();
  111. }
  112.  
  113. void ShellTextView::Term()
  114. {
  115.     Object *op;
  116.     if (text) {
  117.     op= text->RemoveMark(outputCursor);
  118.     SafeDelete(op);
  119.     op= text->RemoveMark(inputCursor);
  120.     SafeDelete(op);
  121.     }
  122.     if (pttyinp) {
  123.     pttyinp->Remove();
  124.     pttyinp= 0;
  125.     }
  126.     if (zombieHandler) {
  127.     zombieHandler->Remove();
  128.     zombieHandler= 0;
  129.     }
  130.     PerformCommand(gResetUndo);
  131.     SafeDelete(pttycon);
  132.     SafeDelete(pttycstr);
  133.     SafeDelete(noEchoBuffer);
  134.     SafeDelete(inpQueue);
  135. }
  136.  
  137. Command *ShellTextView::DoKeyCommand(int ch, Token token)
  138. {
  139.     if (pttycon == 0)
  140.     return gNoChanges;
  141.  
  142.     if (ModifiesReadOnly())
  143.     SetSelection(text->End(), text->End(), TRUE);
  144.     if (pttycon->RawOrCBreak()) {
  145.     char c= ch;
  146.     pttycon->SubmitToSlave(&c, 1);
  147.     lastSubmit= text->End();
  148.     if (pttycon->Echo())
  149.         return TextView::DoKeyCommand(ch, token);
  150.     return gResetUndo;
  151.     }
  152.     if (strchr(pttycstr,ch)) {
  153.     GapText buf(4096), *tosend;
  154.     byte *cbuf;
  155.     int n;
  156.     
  157.     if (ch == pttyc.intr || ch == pttyc.quit) {
  158.         SubmitInterrupt(ch);
  159.         return gResetUndo;
  160.     }
  161.     if (pttycon->Echo()) {
  162.         buf.ReplaceRange(0, buf.End(), text, outputCursor->Pos(), text->End());
  163.         tosend= &buf;
  164.     } else 
  165.         tosend= noEchoBuffer;
  166.     tosend->AddChar(tosend->End(), ch);
  167.     n= tosend->End();
  168.     cbuf= tosend->GetLineAccess(&linebuf, 0, n);
  169.     if (tosend == noEchoBuffer)
  170.         noEchoBuffer->Empty();
  171.     Submit((char*) cbuf, n);
  172.     return gNoChanges;
  173.     }
  174.     if (!pttycon->Echo()) {
  175.     noEchoBuffer->Append(ch);
  176.     return gNoChanges;
  177.     }
  178.     if (text->IsKindOf(StyledText) && ch != '\b') {
  179.     int f, t;
  180.     GetSelection(&f,&t);
  181.     StyledText *st= (StyledText*) text;
  182.     st->SetCharStyle(eTxTPFace, f, t,
  183.           CharStyleSpec(eFontDefault, eFaceBold, 0, 0, FALSE));
  184.     }
  185.     if (Iscntrl(ch) && ch != '\b' && ch != '\t')
  186.     return CntrlChar((byte)ch);
  187.     return TextView::DoKeyCommand(ch, token);
  188. }
  189.  
  190. char *ShellTextView::GetTermCap()
  191. {
  192.     return "etterm|etterm dumb terminal emulator:bs";
  193. }
  194.  
  195. char *ShellTextView::GetTerm()
  196. {
  197.     return "etterm";
  198. }
  199.  
  200. void ShellTextView::Received()
  201. {
  202.     char buf[cPttyBufSize];
  203.     int n= 0, f, t, upto;
  204.     
  205.     Focus();
  206.     inReceive= TRUE;
  207.     GetSelection(&f, &t);
  208.     inputCursor->ChangeMark(f, t-f); 
  209.     outputCursor->Unlock();
  210.     if (pttycon)
  211.     n= pttycon->Read(buf, sizeof(buf)-1);
  212.     
  213.     if (n <= 0)     // EOT from child or lost connection
  214.     SlaveDied();
  215.     else {  
  216.     GapText gt(n);
  217.     HideSelection(FALSE);
  218.     SetNoBatch(pttycon->RawOrCBreak());
  219.     ProcessOutput(>, buf, n);
  220.     if (outputCursor->Pos() < lastSubmit)
  221.         upto= Math::Min(lastSubmit, text->End());
  222.     else 
  223.         upto= outputCursor->Pos();
  224.     InsertReceivedText(>, outputCursor->Pos(), upto);
  225.     if (outputCursor->Pos() > maxLogSize) 
  226.         Wrap();
  227.  
  228.     SetSelection(inputCursor->Pos(), inputCursor->End());
  229.     }
  230.     if (doReveal) { 
  231.     int p= outputCursor->Pos();
  232.     Rectangle r= BoundingRect(p, p).Expand(8);
  233.     RevealOutput(r, r.extent);
  234.     }
  235.     outputCursor->Lock();
  236.     PerformCommand(gResetUndo);
  237.     inReceive= FALSE;
  238.     FlushPendingInput();
  239. }
  240.  
  241. void ShellTextView::FlushPendingInput()
  242. {
  243.     if (inpQueue->Size()) {
  244.     ByteArray *bp;
  245.     Iter next(inpQueue);
  246.     while (bp= (ByteArray*)next()) {
  247.         TtyInput((char*)bp->Str());
  248.         inpQueue->RemovePtr(bp);
  249.         SafeDelete(bp);
  250.     }
  251.     }
  252. }
  253.  
  254. void ShellTextView::InsertReceivedText(Text *t, int from, int to)
  255. {
  256.     if (!text->IsKindOf(StyledText))
  257.     text->Paste(t, from, to);
  258.     else {    
  259.     StyledText *st= (StyledText*) text;
  260.     int upto, ostart= outputCursor->Pos();
  261.     st= (StyledText*) text;
  262.     st->SetCharStyle(eTxTPFace, from, to, CharStyleSpec(eFontDefault, eFacePlain, 0));
  263.     text->Paste(t, from, to);
  264.     if (ostart <= lastSubmit && !pttycon->RawOrCBreak()) {
  265.         upto= Math::Min(Math::Min(lastSubmit, outputCursor->Pos()), text->End());
  266.         st->SetCharStyle(eTxTPFace, ostart, upto, CharStyleSpec(eFontDefault, eFaceBold,0));
  267.         st->SetCharStyle(eTxTPFace, upto, upto, CharStyleSpec(eFontDefault, eFacePlain,0));
  268.     }
  269.     }
  270. }
  271.  
  272. void ShellTextView::ProcessOutput(GapText *gt, char *buf, int n)
  273. {
  274.     for (char *p= buf; p < buf+n; p++) 
  275.     if (HandleSpecialOutChar(*p, gt)) 
  276.         gt->AddChar(gt->End(), *p);
  277. }
  278.  
  279. void ShellTextView::RevealOutput(Rectangle r, Point p)
  280. {
  281.     RevealRect(r, p);
  282. }
  283.  
  284. bool ShellTextView::HandleSpecialOutChar(char p, GapText *t)
  285. {
  286.     if (state) {
  287.     state= FALSE;
  288.     return FALSE;
  289.     } 
  290.     if (pendingCR) {
  291.     if (p == '\r')
  292.         return FALSE;
  293.     if (p == '\n')
  294.         pendingCR= FALSE;
  295.     else {
  296.         CarriageReturn(t);
  297.         pendingCR= FALSE;
  298.     }
  299.     }
  300.     
  301.     switch (p) {
  302.     case cESC: // during a more(1) spurious ESC '9's appear
  303.     state= TRUE;
  304.     return FALSE;
  305.     case '\r':
  306.     pendingCR= TRUE;                         
  307.     break;
  308.     case '\b':
  309.     BackSpace(t, 1);    
  310.     break;
  311.     case '\007':
  312.     gWindow->Bell();
  313.     break;
  314.     default:
  315.     return TRUE;
  316.     }
  317.     return FALSE;
  318. }
  319.  
  320. void ShellTextView::Submit(char *buf, int n)
  321. {
  322.     if (n && pttycon && pttycon->SubmitToSlave(buf, n))
  323.     ShowAlert(eAlertNote, "Pty command buffer overflow\nlast command ignored");
  324.     lastSubmit= text->End();
  325. }
  326.  
  327. void ShellTextView::SubmitInterrupt(char ch)
  328. {
  329.     if (pttycon && pttycon->SubmitToSlave(&ch, 1))
  330.     pttycon->SubmitToSlave(&ch, 1); // try again after flush of buffers
  331. }
  332.  
  333. void ShellTextView::Done()
  334. {
  335.     if (pttycon)
  336.     pttycon->KillChild();
  337. } 
  338.  
  339. bool ShellTextView::IsIdle()
  340. {
  341.     return pttycon == 0;
  342. } 
  343.  
  344. void ShellTextView::SlaveDied()
  345. {
  346.     if (pttycon) 
  347.     CleanupDeath();
  348.     zombieHandler= 0;
  349. }
  350.  
  351. void ShellTextView::CleanupDeath()
  352. {
  353.     if (pttyinp) {
  354.     pttyinp->Remove();
  355.     pttyinp= 0;
  356.     }
  357.     ClearOutput();
  358.     SafeDelete(pttycon);
  359. }
  360.  
  361. void ShellTextView::DrawOutputCursor(Point p)
  362. {
  363.     Point hotspot(-crevCaretHeight, 0);
  364.     Rectangle r(p+hotspot, Point(7,4));
  365.     r.origin+= GetInnerOrigin();
  366.     
  367.     if (GrHasColor()) {
  368.     if (gCaretColor == 0)
  369.         gCaretColor= new_RGBColor(0, 0, 255);
  370.     GrPaintBitMap(r, gRevCaretImage, gCaretColor);
  371.     } else
  372.     GrPaintBitMap(r, gRevCaretImage, ePatXor);
  373. }
  374.  
  375. void ShellTextView::Draw(Rectangle r)
  376. {
  377.     Point p;
  378.     int l;
  379. //    if (!pttycon)
  380. //        GrPaintRect(r, ePatGrey25);
  381.     TextView::Draw(r);
  382.     if (pttycon && pttycon->RawOrCBreak())
  383.     return;
  384.     CharToPoint(outputCursor->Pos(), &l, &p);
  385.     DrawOutputCursor(p);
  386. }
  387.  
  388. void ShellTextView::Paste(Text *insert)
  389. {
  390.     if (ModifiesReadOnly())
  391.     return;
  392.     if (pttycon && pttycon->RawOrCBreak()) {
  393.     AutoTextIter next(insert);
  394.     Token t;
  395.     int ch;
  396.     while ((ch= next()) != cEOT) {
  397.         t.Code= (short)ch;
  398.         DoKeyCommand((short)ch, t);
  399.     }
  400.     } else
  401.     TextView::Paste(insert);
  402. }
  403.  
  404. bool ShellTextView::ModifiesReadOnly()
  405. {
  406.     int f, t;
  407.     GetSelection(&f, &t);
  408.     return f < outputCursor->Pos();
  409. }
  410.     
  411. bool ShellTextView::DeleteRequest(int from, int)
  412. {
  413.     return from >= outputCursor->Pos();
  414. }
  415.  
  416. void ShellTextView::BecomeConsole()
  417. {
  418.     if (pttycon)
  419.     pttycon->BecomeConsole();
  420. }
  421.  
  422. void ShellTextView::BackSpace(Text *t, int n)
  423. {
  424.     int s= t->End();
  425.     if (s > 0) {
  426.     int d1= Math::Min(s, n);
  427.     t->Cut(s-d1, s);
  428.     }
  429.     if (n > s) {
  430.     int d2= n-s;
  431.     lastSubmit= Math::Max(0, lastSubmit-d2);
  432.     int p= outputCursor->Pos();
  433.     outputCursor->ChangeMark(Math::Max(0, p-d2), 0);
  434.     text->Cut(p-d2,p);
  435.     }
  436. }
  437.  
  438. void ShellTextView::CarriageReturn(Text *t)
  439. {
  440.     int s= t->End(), ch;
  441.     pendingCR= FALSE;
  442.     while (s > 0) {
  443.     int ch= (*t)[s];
  444.     if (ch == '\n' || ch == '\r') {
  445.         t->Cut(s+1,t->End());
  446.         return;
  447.     }
  448.     s--;
  449.     }
  450.     t->Empty();
  451.     s= text->End();
  452.     int at= s-1;
  453.     while (at >= 0) {
  454.     ch= (*text)[at];
  455.     if (ch == '\n' || ch == '\r') {
  456.         outputCursor->ChangeMark(at+1, 0);
  457.         text->Cut(at+1, s);
  458.         lastSubmit= at+1;
  459.         return;
  460.     }
  461.     at--;
  462.     }
  463. }
  464.  
  465. Command *ShellTextView::CntrlChar(byte b)
  466. {
  467.     GapText gt((byte*)"^");
  468.     gt.Append(b+'@');
  469.     return InsertText(>);
  470. }
  471.  
  472. void ShellTextView::Wrap()
  473. {
  474.     int line, del, at= outputCursor->Pos();
  475.     line= CharToLine(Math::Max(0, text->End()-cLowWaterMark));
  476.     del= StartLine(line);
  477.     lastSubmit-= del;
  478.     text->Cut(0, del);
  479. }
  480.  
  481. Text *ShellTextView::SetText(Text *t, bool revealTop)
  482. {
  483.     Text *ot= TextView::SetText(t, revealTop);
  484.     if (ot) {
  485.     ot->RemoveMark(outputCursor);
  486.     ot->RemoveMark(inputCursor);
  487.     }
  488.     t->AddMark(outputCursor);
  489.     t->AddMark(inputCursor);
  490.     MarksToEOT();
  491.     return ot;
  492. }
  493.  
  494. void ShellTextView::MarksToEOT()
  495. {
  496.     Text *t= GetText();
  497.     outputCursor->ChangeMark (t->End(), 0);
  498.     outputCursor->Lock();
  499.     inputCursor->ChangeMark (t->End(), 0);
  500.     lastSubmit= t->End();
  501. }
  502.  
  503. void ShellTextView::ClearOutput()
  504. {
  505.     text->Cut(0, text->End());
  506.     MarksToEOT();
  507.     SetSelection(0,0,FALSE);
  508.     RevealSelection();
  509. }
  510.  
  511. void ShellTextView::DoReveal(bool b)
  512. {
  513.     if (!doReveal && b)
  514.     RevealSelection();
  515.     doReveal= b;
  516. }
  517.  
  518. void ShellTextView::Start(char *name, char **args, bool cons)
  519. {
  520.     if (pttycon != 0)
  521.     Error("Start", "shell is already running");
  522.     
  523.     state= 0;
  524.     MarksToEOT();
  525.     if (name == 0)
  526.     name= gDefaultArgv[0];
  527.     argv= args;
  528.     if (args == 0)
  529.     argv= gDefaultArgv;
  530.     pttycon= gSystem->MakePttyConnection(name, argv);
  531.     if (!pttycon)
  532.     Error("Start", "cannot establish connection with tty");
  533.     if (cons)
  534.     BecomeConsole(); 
  535.     if (pttycon->GetFile() == 0)
  536.     Error("Start", "could not spawn slave pseudo tty");  
  537.     pttycon->GetPttyChars(&pttyc);
  538.     pttycstr= strprintf("\n\r%c%c%c%c%c", pttyc.rprnt, pttyc.susp, 
  539.                            pttyc.intr, pttyc.quit,
  540.                            pttyc.eof);
  541.     SetStopChars(pttycstr);
  542.     gSystem->AddFileInputHandler(
  543.            pttyinp= new PttyInputHandler(pttycon->GetFile(), this));
  544.     gSystem->AddZombieHandler(
  545.            zombieHandler= new ShellZombieHandler(pttycon->GetPid(), this));       
  546. }
  547.  
  548. void ShellTextView::Reconnect() 
  549. {
  550.     if (pttycon) {
  551.      switch (ShowAlert(eAlertCaution, "There is alreay a shell connection.\nForce reconnect?")) {
  552.         case cIdYes:
  553.             pttycon= 0;
  554.             break;
  555.         case cIdNo:
  556.         case cIdCancel:
  557.             return;
  558.         }
  559.     }    
  560.     Start(argv[0], argv);
  561.     ForceRedraw();
  562. }
  563.  
  564. Menu *ShellTextView::MakeMenu(int menuId)
  565. {
  566.     Menu *m;
  567.     
  568.     if (menuId == cSHELLMENU) {
  569.     m= new Menu(cSHELLMENU, "Shell");
  570.     m->AppendItems( 
  571.             "Auto Reveal On",   cAUTOREVEAL,
  572.             "Reconnect",        cRECONNECT,
  573.             "Become Console",   cBECOMECONSOLE,
  574.             "Do It",            cDOIT,
  575.             0);
  576.     }
  577.     else
  578.     m= TextView::MakeMenu(menuId);
  579.     return m;
  580. }
  581.  
  582. void ShellTextView::DoSetupMenu(Menu *m)
  583. {
  584.     char *current;
  585.  
  586.     TextView::DoSetupMenu(m);
  587.     if (ModifiesReadOnly()) {
  588.     m->DisableItem(cCUT);
  589.     m->DisableItem(cPASTE);
  590.     }
  591.     if (doReveal)
  592.     current= "Auto reveal off";
  593.     else
  594.     current= "Auto reveal on";
  595.  
  596.     m->ReplaceItem(cAUTOREVEAL, current);
  597.     if (pttycon)
  598.     m->EnableItem(cBECOMECONSOLE);
  599.     m->EnableItem(cRECONNECT);
  600.     m->EnableItems(cCLEAR, cAUTOREVEAL, 0);
  601.     if (!Caret())
  602.     m->EnableItem(cDOIT);
  603. }
  604.     
  605. Command *ShellTextView::DoMenuCommand(int cmd)
  606. {
  607.     switch (cmd) {
  608.  
  609.     case cAUTOREVEAL:
  610.     DoReveal(!doReveal);
  611.     break;
  612.     
  613.     case cCLEAR:
  614.     ClearOutput();
  615.     return gResetUndo;
  616.     
  617.     case cRECONNECT:
  618.     Reconnect();
  619.     break;
  620.     
  621.     case cBECOMECONSOLE:
  622.     pttycon->BecomeConsole();
  623.     break;
  624.  
  625.     case cDOIT:
  626.     Doit();
  627.     return gResetUndo;
  628.     }
  629.     return TextView::DoMenuCommand(cmd);
  630. }
  631.  
  632. void ShellTextView::SelectAll(bool redraw)
  633. {
  634.     SetSelection(outputCursor->Pos(), text->End(), redraw);
  635.     RevealSelection();
  636. }
  637.  
  638. void ShellTextView::Doit()
  639. {
  640.     int f, t;
  641.     GapText buf(256);
  642.     Token token;
  643.     
  644.     GetSelection(&f, &t);
  645.     text->Copy(&buf,f, t);
  646.     SetSelection(text->End(), text->End());
  647.     Paste(&buf);
  648.     DoKeyCommand('\n', token);
  649. }
  650.  
  651. char **ShellTextView::GetArgv()
  652. { 
  653.     return argv; 
  654. }
  655.     
  656. PttyConnection *ShellTextView::GetPtty()
  657. {
  658.     return pttycon;
  659. }
  660.  
  661. void ShellTextView::SetTtySize(Rectangle r, Font *fd)
  662. {
  663.     int cols= r.extent.x / fd->Width(' ');
  664.     Metric m= MeasureText(0, fd, r.extent.x, 1);
  665.     int rows= r.extent.y / m.Height(); 
  666.     SetTtySize(rows, cols);
  667. }
  668.  
  669. void ShellTextView::ChangedViewRect(Rectangle r)
  670. {
  671.     SetTtySize(r, text->GetFont(0)); 
  672.     if (Width() != r.Width())
  673.     SetWidth(r.Width());
  674. }
  675.  
  676. void ShellTextView::SetTtySize(int rows, int cols)
  677. {
  678.     if (pttycon)
  679.     pttycon->SetSize(rows, cols);
  680. }
  681.  
  682. void ShellTextView::SetMaxLogSize(int n)
  683. {
  684.     maxLogSize= n;
  685. }
  686.  
  687. Command *ShellTextView::TtyInput(char *buf, int len)
  688. {
  689.     Token t;
  690.     
  691.     if (inReceive) {
  692.     inpQueue->Add(new ByteArray(buf, len));
  693.     return gNoChanges;
  694.     }
  695.     Command *cmd= gNoChanges;
  696.     if (len == -1)
  697.     len= strlen(buf);
  698.     for (char *cp= buf; cp < buf+len; cp++) {
  699.     t.Code= (short)*cp;
  700.     cmd= DoKeyCommand((int)*cp, t);
  701.     }
  702.     PerformCommand(gResetUndo);
  703.     return cmd;
  704. }
  705.  
  706. OStream& ShellTextView::PrintOn(OStream &s)
  707. {
  708.     TextView::PrintOn(s);
  709.     return s << doReveal SP;
  710. }
  711.  
  712. IStream& ShellTextView::ReadFrom(IStream &s)
  713. {
  714.     TextView::ReadFrom(s);
  715.     Term();
  716.     s >> Bool(doReveal);
  717.     Init(doReveal, gDefaultArgv[0], gDefaultArgv, FALSE);
  718.     MarksToEOT();
  719.     return s;
  720. }
  721.